home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / sun / font / BidiUtils.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  2.2 KB  |  241 lines
  1. package sun.font;
  2.  
  3. import java.text.Bidi;
  4.  
  5. public final class BidiUtils {
  6.    static final char NUMLEVELS = '>';
  7.  
  8.    public static void getLevels(Bidi var0, byte[] var1, int var2) {
  9.       int var3 = var2 + var0.getLength();
  10.       if (var2 >= 0 && var3 <= var1.length) {
  11.          int var4 = var0.getRunCount();
  12.          int var5 = var2;
  13.  
  14.          for(int var6 = 0; var6 < var4; ++var6) {
  15.             int var7 = var2 + var0.getRunLimit(var6);
  16.  
  17.             for(byte var8 = (byte)var0.getRunLevel(var6); var5 < var7; var1[var5++] = var8) {
  18.             }
  19.          }
  20.  
  21.       } else {
  22.          throw new IndexOutOfBoundsException("levels.length = " + var1.length + " start: " + var2 + " limit: " + var3);
  23.       }
  24.    }
  25.  
  26.    public static byte[] getLevels(Bidi var0) {
  27.       byte[] var1 = new byte[var0.getLength()];
  28.       getLevels(var0, var1, 0);
  29.       return var1;
  30.    }
  31.  
  32.    public static int[] createVisualToLogicalMap(byte[] var0) {
  33.       int var1 = var0.length;
  34.       int[] var2 = new int[var1];
  35.       byte var3 = 63;
  36.       byte var4 = 0;
  37.  
  38.       for(int var5 = 0; var5 < var1; ++var5) {
  39.          var2[var5] = var5;
  40.          byte var6 = var0[var5];
  41.          if (var6 > var4) {
  42.             var4 = var6;
  43.          }
  44.  
  45.          if ((var6 & 1) != 0 && var6 < var3) {
  46.             var3 = var6;
  47.          }
  48.       }
  49.  
  50.       label58:
  51.       for(; var4 >= var3; --var4) {
  52.          int var9 = 0;
  53.  
  54.          while(true) {
  55.             while(var9 >= var1 || var0[var9] >= var4) {
  56.                int var10 = var9++;
  57.                if (var10 == var0.length) {
  58.                   continue label58;
  59.                }
  60.  
  61.                while(var9 < var1 && var0[var9] >= var4) {
  62.                   ++var9;
  63.                }
  64.  
  65.                for(int var7 = var9 - 1; var10 < var7; --var7) {
  66.                   int var8 = var2[var10];
  67.                   var2[var10] = var2[var7];
  68.                   var2[var7] = var8;
  69.                   ++var10;
  70.                }
  71.             }
  72.  
  73.             ++var9;
  74.          }
  75.       }
  76.  
  77.       return var2;
  78.    }
  79.  
  80.    public static int[] createInverseMap(int[] var0) {
  81.       if (var0 == null) {
  82.          return null;
  83.       } else {
  84.          int[] var1 = new int[var0.length];
  85.  
  86.          for(int var2 = 0; var2 < var0.length; var1[var0[var2]] = var2++) {
  87.          }
  88.  
  89.          return var1;
  90.       }
  91.    }
  92.  
  93.    public static int[] createContiguousOrder(int[] var0) {
  94.       return var0 != null ? computeContiguousOrder(var0, 0, var0.length) : null;
  95.    }
  96.  
  97.    private static int[] computeContiguousOrder(int[] var0, int var1, int var2) {
  98.       int[] var3 = new int[var2 - var1];
  99.  
  100.       for(int var4 = 0; var4 < var3.length; ++var4) {
  101.          var3[var4] = var4 + var1;
  102.       }
  103.  
  104.       for(int var8 = 0; var8 < var3.length - 1; ++var8) {
  105.          int var5 = var8;
  106.          int var6 = var0[var3[var8]];
  107.  
  108.          for(int var7 = var8; var7 < var3.length; ++var7) {
  109.             if (var0[var3[var7]] < var6) {
  110.                var5 = var7;
  111.                var6 = var0[var3[var7]];
  112.             }
  113.          }
  114.  
  115.          int var11 = var3[var8];
  116.          var3[var8] = var3[var5];
  117.          var3[var5] = var11;
  118.       }
  119.  
  120.       if (var1 != 0) {
  121.          for(int var9 = 0; var9 < var3.length; ++var9) {
  122.             var3[var9] -= var1;
  123.          }
  124.       }
  125.  
  126.       int var10;
  127.       for(var10 = 0; var10 < var3.length && var3[var10] == var10; ++var10) {
  128.       }
  129.  
  130.       if (var10 == var3.length) {
  131.          return null;
  132.       } else {
  133.          return createInverseMap(var3);
  134.       }
  135.    }
  136.  
  137.    public static int[] createNormalizedMap(int[] var0, byte[] var1, int var2, int var3) {
  138.       if (var0 != null) {
  139.          if (var2 == 0 && var3 == var0.length) {
  140.             return var0;
  141.          } else {
  142.             boolean var4;
  143.             boolean var5;
  144.             byte var6;
  145.             if (var1 == null) {
  146.                var6 = 0;
  147.                var4 = true;
  148.                var5 = true;
  149.             } else if (var1[var2] == var1[var3 - 1]) {
  150.                var6 = var1[var2];
  151.                var5 = (var6 & 1) == 0;
  152.  
  153.                int var7;
  154.                for(var7 = var2; var7 < var3 && var1[var7] >= var6; ++var7) {
  155.                   if (var5) {
  156.                      var5 = var1[var7] == var6;
  157.                   }
  158.                }
  159.  
  160.                var4 = var7 == var3;
  161.             } else {
  162.                var4 = false;
  163.                var6 = 0;
  164.                var5 = false;
  165.             }
  166.  
  167.             if (!var4) {
  168.                return computeContiguousOrder(var0, var2, var3);
  169.             } else if (var5) {
  170.                return null;
  171.             } else {
  172.                int[] var10 = new int[var3 - var2];
  173.                int var8;
  174.                if ((var6 & 1) != 0) {
  175.                   var8 = var0[var3 - 1];
  176.                } else {
  177.                   var8 = var0[var2];
  178.                }
  179.  
  180.                if (var8 == 0) {
  181.                   System.arraycopy(var0, var2, var10, 0, var3 - var2);
  182.                } else {
  183.                   for(int var9 = 0; var9 < var10.length; ++var9) {
  184.                      var10[var9] = var0[var9 + var2] - var8;
  185.                   }
  186.                }
  187.  
  188.                return var10;
  189.             }
  190.          }
  191.       } else {
  192.          return null;
  193.       }
  194.    }
  195.  
  196.    public static void reorderVisually(byte[] var0, Object[] var1) {
  197.       int var2 = var0.length;
  198.       byte var3 = 63;
  199.       byte var4 = 0;
  200.  
  201.       for(int var5 = 0; var5 < var2; ++var5) {
  202.          byte var6 = var0[var5];
  203.          if (var6 > var4) {
  204.             var4 = var6;
  205.          }
  206.  
  207.          if ((var6 & 1) != 0 && var6 < var3) {
  208.             var3 = var6;
  209.          }
  210.       }
  211.  
  212.       label58:
  213.       for(; var4 >= var3; --var4) {
  214.          int var9 = 0;
  215.  
  216.          while(true) {
  217.             while(var9 >= var2 || var0[var9] >= var4) {
  218.                int var10 = var9++;
  219.                if (var10 == var0.length) {
  220.                   continue label58;
  221.                }
  222.  
  223.                while(var9 < var2 && var0[var9] >= var4) {
  224.                   ++var9;
  225.                }
  226.  
  227.                for(int var7 = var9 - 1; var10 < var7; --var7) {
  228.                   Object var8 = var1[var10];
  229.                   var1[var10] = var1[var7];
  230.                   var1[var7] = var8;
  231.                   ++var10;
  232.                }
  233.             }
  234.  
  235.             ++var9;
  236.          }
  237.       }
  238.  
  239.    }
  240. }
  241.